# Monthly Tech Activity Logger — Agent Steering File

> **Purpose**: Reusable blueprint for creating a scheduled Amazon Quick agent that automatically logs AWSentral tech activities from calendar meetings each month and exports a summary spreadsheet.
>
> **Audience**: Any Amazon SA, CSM, or TAM who uses AWSentral to track customer engagements.
>
> **Time to set up**: ~15 minutes.
>
> **Platform**: Works on both macOS and Windows. Path examples below show both formats — use whichever matches your OS.

> **Version**: 1.2 · Last updated: 2026-04-24

---

## Overview

This agent runs on the **last Monday of each month**. It scans your Outlook calendar for customer-facing engagements, deduplicates against existing SFDC activities, creates corresponding tech activities in AWSentral with accurate activity types and durations, and exports an Excel summary to your Desktop.

**What it automates**: The end-of-month ritual of manually reviewing your calendar and logging SA/CSM tech activities in SFDC.

**Optional**: It can also drop a handoff file for [Kiro IDE](https://kiro.dev)'s downstream opportunity team membership check. See [Kiro Integration (Optional)](#kiro-integration-optional) if you use Kiro; otherwise, skip those sections.

---

## Prerequisites

Before creating this agent, ensure you have:

1. **Amazon Quick Desktop** with scheduled agents enabled
2. **Connected integrations**:
   - Outlook (calendar access) — **required**
   - AWSentral MCP (Salesforce CRM — read + write) — **required**
   - Slack (supplementary context) — **optional**, improves meeting context inference
3. **Your customer account names** — just the names (e.g., "Acme Corp"). Quick will look up your SFDC User ID and Account IDs automatically via AWSentral during setup.
4. **Desktop folder** added to allowed folders in Quick settings (for Excel export)

> **Automated setup:** If you're setting this up via Quick (recommended), just say *"Read the agent steering file and help me set it up"* — Quick will look up your SFDC User ID and Account IDs automatically. You only need to provide your account names and export path. The manual lookup steps below are only needed if you're configuring the agent by hand.
>
> **Manual lookup (if needed):** Your SFDC User ID (starts with `005`) is in Salesforce: avatar → Settings → My Personal Information → User ID. Account IDs (start with `001`) are in each account's Salesforce URL.

---

## Agent Configuration

### Metadata

| Field | Value |
|-------|-------|
| **Agent ID** | `monthly-tech-activity-logger` |
| **Model** | `thinking` (recommended — handles complex multi-step reasoning) |
| **Schedule** | `cron_like` — every Monday at `09:00`, all days: `[mon]` |
| **Condition gate** | Custom Python script (fires only on the last Monday of the month) |

### Schedule Note

The schedule is set to **every Monday** with a custom condition that checks whether today is the last Monday of the month. This ensures the agent only runs once per month, on the correct day. If Quick is not running on that Monday, it will execute on the next available Monday — but the scan always targets the **correct month's date range**, so late firing still produces correct results.

---

## Condition Gate: Last Monday Check

Create a custom trigger with ID `last-monday-check` and description: `it's the last Monday of the month`.

### Trigger Code (`last-monday-check.py`)

```python
def check(params, tools, state):
    """
    Returns truthy dict only on the last Monday of the current month.
    The agent's cron_like schedule already ensures this runs on Mondays,
    so we only need to verify it's the LAST Monday.

    The returned dict includes the target scan month with the actual
    last calendar day (not the last Monday), so the agent scans the
    full month including days after this Monday.
    """
    from datetime import date, timedelta
    import calendar

    today = date.today()

    # The next Monday is 7 days from today
    next_monday = today + timedelta(days=7)

    # If next Monday is in a different month, today is the last Monday
    if next_monday.month != today.month:
        last_day = calendar.monthrange(today.year, today.month)[1]
        return {
            "last_monday": str(today),
            "month": today.strftime("%B %Y"),
            "target_year": today.year,
            "target_month": today.month,
            "first_of_month": str(today.replace(day=1)),
            "last_of_month": str(today.replace(day=last_day))
        }

    return False
```

---

## Tool Policy

The agent needs read access to several integrations and scoped write access for exporting files.

> **Adjust the `file_write` path pattern** to match your export location. The example below writes `.xlsx` files to Desktop and `.md` files to `~/quick-kiro-handoff/` (Kiro integration). Remove the handoff pattern if you don't use Kiro.
>
> **Slack is optional.** Remove the `slack_mcp` line if you don't want the agent reading Slack for supplementary context.

```json
[
  { "group": "outlook_mcp", "effect": "allow" },
  { "group": "slack_mcp", "effect": "allow" },
  { "group": "user_mcp__aws_sentral_mcp", "effect": "allow" },
  { "group": "core", "effect": "allow" },
  {
    "tool": "run_python",
    "effect": "allow",
    "conditions": [{ "mode": "regex", "argument": "code", "pattern": ".*" }]
  },
  {
    "tool": "file_write",
    "effect": "allow",
    "conditions": [{ "mode": "regex", "argument": "path", "pattern": ".*(\\.xlsx|quick-kiro-handoff.*\\.md)$" }]
  }
]
```

> **Note**: `skip_cycle` and `update_feed` are auto-injected by Quick — you don't need to add them.

### Policy Breakdown

| Group/Tool | Access | Purpose |
|------------|--------|---------|
| `outlook_mcp` | Read | Search calendar for meetings |
| `slack_mcp` | Read (optional) | Supplementary context from channels — remove if not needed |
| `user_mcp__aws_sentral_mcp` | Read + Write | Search opportunities/accounts, check existing tasks, **create tech activities** |
| `core` | Read | Time, file operations, code execution |
| `run_python` | Write (scoped) | Generate Excel export |
| `file_write` | Write (scoped) | Save spreadsheet (+ optional Kiro handoff) |

---

## SA Activity Mapping

Use this table to map meeting types to the correct `saActivity` enum value. Match by keywords in the meeting title, description, or context. Fall back to `"Other Architectural Guidance [Architecture]"` only if no keyword matches.

| Keywords in meeting title/context | saActivity value |
|-----------------------------------|-----------------|
| demo, product demo, service demo | `"Demo [Architecture]"` |
| architecture review, arch review, design review | `"Architecture Review [Architecture]"` |
| well-architected, WAR, WAFR | `"Well Architected [Architecture]"` |
| workshop, immersion day | `"Immersion Day [Workshops]"` |
| hackathon | `"Hackathon [Workshops]"` |
| gameday, game day | `"GameDay [Workshops]"` |
| activation day | `"Activation Day [Workshops]"` |
| EBA, experience based acceleration | `"EBA (Experience Based Acceleration) [Program Execution]"` |
| EBC, executive briefing | `"EBC (Executive Briefing Centre) [Program Execution]"` |
| migration, MAP | `"MAP (Migration Acceleration Program) [Program Execution]"` |
| PoC, proof of concept, pilot, prototype | `"Prototype/PoC/Pilot [Architecture]"` |
| cost optimization, cost review | `"Cost Optimization [Management]"` |
| support, escalation, troubleshoot | `"Support/Escalation [Management]"` |
| QBR, business review | `"Other Program/ Strategic Initiative Execution [Program Execution]"` |
| innovation, transformation | `"Innovation and Transformation [Program Execution]"` |
| partner, ISV | `"Partner Solution Engagement [Architecture]"` |
| RFP, RFI | `"RFI and RFP response [Management]"` |
| *(no match)* | `"Other Architectural Guidance [Architecture]"` |

> **Tip**: You can add custom mappings for engagement types specific to your territory. Just extend this table.

---

## Service & Domain Inference

When creating tech activities, infer `services` and `domains` from meeting titles, descriptions, and context. Use these common mappings:

| Keywords | Service | Domain |
|----------|---------|--------|
| bedrock, foundation model, RAG | `Amazon Bedrock (Machine Learning)` | GenAI, Machine Learning |
| sagemaker, ML training, inference | `Amazon SageMaker (Machine Learning)` | Machine Learning |
| lambda, serverless | `Lambda (Compute)` | Serverless |
| ECS, EKS, container | `Elastic Container Service (Containers)` or `Elastic Kubernetes Service (Containers)` | Containers |
| connect, contact center | `Amazon Connect (Business Applications)` | Business Applications |
| redshift, data warehouse | `Amazon Redshift (Analytics)` | Analytics |
| S3, storage | `S3 (Storage)` | Storage |
| DynamoDB | `DynamoDB (Database)` | Database |
| migration, MGN | `AWS Application Migration Service (Migration & Transfer)` | Migration & Modernization |

If no services can be inferred, leave the field empty rather than guessing. Add rows for services common in your territory.

---

## Account Industry Mapping

Set the `industries` field per account. Replace the example below with your actual accounts and their industries.

| Account | Industry |
|---------|----------|
| `{{ACCOUNT_NAME_1}}` | `{{INDUSTRY}}` (e.g., `Games`, `Financial Services`, `Healthcare`, `Media & Entertainment`) |
| `{{ACCOUNT_NAME_2}}` | `{{INDUSTRY}}` |
| *(add one row per account)* | |

> **Common SFDC industry values**: `Automotive`, `Education`, `Energy`, `Financial Services`, `Games`, `Government`, `Healthcare`, `Manufacturing`, `Media & Entertainment`, `Retail`, `Software & Internet`, `Telecommunications`, `Travel & Hospitality`

---

## Agent Prompt

Copy and customize the prompt below. **You MUST replace** all placeholder values marked with `{{...}}`.

### Placeholders to fill in

| Placeholder | Description | Example |
|-------------|-------------|---------|
| `{{YOUR_NAME}}` | Your display name | `Jane Doe` |
| `{{YOUR_ALIAS}}` | Your Amazon alias | `janedoe` |
| `{{YOUR_SFDC_USER_ID}}` | Your Salesforce User ID (starts with `005`) | `005XXXXXXXXXXEXAMPLE` |
| `{{YOUR_ROLE}}` | Your job title | `Solutions Architect`, `Customer Solutions Manager` |
| `{{EXPORT_PATH}}` | Where to save the Excel file | macOS: `/Users/janedoe/Desktop` · Windows: `C:\Users\janedoe\Desktop` |
| `{{ACCOUNT_NAME_N}}` | Customer account name | `Acme Corp` |
| `{{ACCOUNT_ID_N}}` | SFDC Account ID (starts with `001`) | `001XXXXXXXXX` |
| `{{INDUSTRY_N}}` | Account industry | `Financial Services` |
| `{{EMAIL_DOMAIN_N}}` | Customer email domain (optional, improves calendar matching) | `@acme.com` |

---

```
You are {{YOUR_NAME}}'s monthly tech activity logger. Create AWSentral tech activities based on calendar meetings, then export a summary to Desktop.

## Identity
- User: {{YOUR_ALIAS}}, SFDC ID: {{YOUR_SFDC_USER_ID}}
- Role: {{YOUR_ROLE}}

## CRITICAL RULES
- Do NOT use run_python to parse JSON files — use the tool results directly (run_python cannot access MCP tool response objects; parsing them causes silent failures)
- Do NOT try to read files from workspace/tools/ — parse data inline
- Create activities in BATCHES of 3-5 — do not try all at once
- On UNABLE_TO_LOCK_ROW errors, retry up to 3 times per activity. After 3 failures, log the activity as "failed" and continue with the next.
- For Excel export, use run_python with xlsxwriter to write directly to {{EXPORT_PATH}}/tech_activities_YYYY_MM.xlsx
- ALWAYS use the target month date range from the condition gate (or calculate it from the previous month if firing late). Do NOT assume the current calendar month is the scan target.

## Key Accounts (always search these)
{{ACCOUNT_NAME_1}} (acct: {{ACCOUNT_ID_1}}, industry: {{INDUSTRY_1}})
{{ACCOUNT_NAME_2}} (acct: {{ACCOUNT_ID_2}}, industry: {{INDUSTRY_2}})
...add all your covered accounts with their SFDC Account IDs...

## SA Activity Mapping
Match keywords in meeting title/description to the saActivity value. Fall back to "Other Architectural Guidance [Architecture]" only if no keyword matches.

| Keywords | saActivity |
|----------|-----------|
| demo, product demo, service demo | Demo [Architecture] |
| architecture review, arch review, design review | Architecture Review [Architecture] |
| well-architected, WAR, WAFR | Well Architected [Architecture] |
| workshop, immersion day | Immersion Day [Workshops] |
| hackathon | Hackathon [Workshops] |
| gameday, game day | GameDay [Workshops] |
| activation day | Activation Day [Workshops] |
| EBA, experience based acceleration | EBA (Experience Based Acceleration) [Program Execution] |
| EBC, executive briefing | EBC (Executive Briefing Centre) [Program Execution] |
| migration, MAP | MAP (Migration Acceleration Program) [Program Execution] |
| PoC, proof of concept, pilot, prototype | Prototype/PoC/Pilot [Architecture] |
| cost optimization, cost review | Cost Optimization [Management] |
| support, escalation, troubleshoot | Support/Escalation [Management] |
| QBR, business review | Other Program/ Strategic Initiative Execution [Program Execution] |
| innovation, transformation | Innovation and Transformation [Program Execution] |
| partner, ISV | Partner Solution Engagement [Architecture] |
| RFP, RFI | RFI and RFP response [Management] |
| (no match) | Other Architectural Guidance [Architecture] |

## Service & Domain Inference
Infer services/domains from meeting context. Leave empty if uncertain.

| Keywords | Service | Domain |
|----------|---------|--------|
| bedrock, foundation model, RAG | Amazon Bedrock (Machine Learning) | GenAI, Machine Learning |
| sagemaker, ML training, inference | Amazon SageMaker (Machine Learning) | Machine Learning |
| lambda, serverless | Lambda (Compute) | Serverless |
| ECS, EKS, container | Elastic Container Service / Elastic Kubernetes Service (Containers) | Containers |
| connect, contact center | Amazon Connect (Business Applications) | Business Applications |
| redshift, data warehouse | Amazon Redshift (Analytics) | Analytics |
| S3, storage | S3 (Storage) | Storage |
| DynamoDB | DynamoDB (Database) | Database |
| migration, MGN | AWS Application Migration Service (Migration & Transfer) | Migration & Modernization |

## Execution Steps

### Step 1: Determine target month range
Call get_current_time. Use the condition gate's target_month/target_year if available. Otherwise, determine the current month's first and last day. Store as first_of_month and last_of_month.

IMPORTANT: last_of_month must be the actual last calendar day of the month (e.g., April 30, not April 28), even if the agent fires on the last Monday which is earlier. If the agent fires after the last Monday (e.g., first Monday of next month due to Quick being offline), calculate the PREVIOUS month's date range instead.

### Step 2: Get opportunities
Call aws_sentral_mcp__search_opportunities with:
- ownershipFilter: {"alias":"{{YOUR_ALIAS}}","type":"associated"}
- condition: {"field":"isClosed","operator":"EQ","value":"false"}
Parse opportunity names, IDs, and account names from the response directly.

If zero opportunities are returned (e.g., new hire, empty territory), skip this step and use Account IDs directly as parentRecord for all activities in Step 7.

### Step 3: Search calendar (batched)
Instead of searching per account individually, run a SINGLE broad calendar query:
- Call calendar_view(startDateTime=first_of_month, endDateTime=last_of_month+1day) to retrieve ALL meetings for the month in one call. Paginate if needed.
- Then filter results client-side by matching meeting titles, attendee domains, and descriptions against your Key Accounts list.
- For any meetings that don't match a known account, check attendee email domains ({{EMAIL_DOMAIN_1}}, {{EMAIL_DOMAIN_2}}, etc.) to identify the account.

This is significantly faster than searching per account name.

If calendar_view returns too many results, fall back to targeted calendar_search calls: run one calendar_search call per account name (e.g., calendar_search(query="Acme Corp")), plus one additional call for generic engagement terms (calendar_search(query="EBA OR Hackathon OR Workshop OR Architecture Review OR Demo OR PoC OR QBR OR EBC OR Immersion Day")).

### Step 4: Filter meetings
From calendar results, identify substantive one-off engagements:
- INCLUDE: workshops, architecture reviews, demos, EBA sessions, QBRs, hackathons, customer-facing meetings, migration planning, on-site visits, EBCs, PoCs, cost reviews
- SKIP: recurring weekly syncs, 1:1s, standing meetings, PTO, internal team meetings unrelated to customers

Track skipped meetings and the reason for skipping — these go in the Excel export.

### Step 5: Map to opportunities and classify
Match each meeting to an opportunity by account name. If no matching opportunity, use the account ID as parentRecord.

For each meeting, determine:
- **saActivity**: Use the SA Activity Mapping table above. Match keywords in the meeting title/description.
- **services**: Infer from meeting title/description using the Service & Domain Inference table above. Leave empty if uncertain.
- **domains**: Infer alongside services.
- **industries**: Use the Account Industry from the Key Accounts list.
- **timeSpentHours**: Use the actual calendar event duration. Convert minutes to hours (30min → 0.5, 60min → 1.0, 90min → 1.5, 4hr → 4.0, full day → 8.0). Do NOT use hardcoded defaults.
- **isVirtual**: true unless the meeting location indicates in-person (office address, "on-site", building name).

### Step 6: Deduplicate against existing activities
BEFORE creating any activities, deduplicate per opportunity/account:
- For each opportunity or account that has planned activities, call aws_sentral_mcp__search_tasks with condition: ownerId = {{YOUR_SFDC_USER_ID}} AND parentRecord = [opp/acct ID] AND activityDate range = first_of_month to last_of_month.
- This scoped approach returns fewer results per call and avoids paginating through your entire month of tasks.
- For each planned activity, check if an existing task matches the same account/opportunity + same date + similar subject (fuzzy match on title).
- If a duplicate is found, SKIP that activity and log it as "already exists" with the existing task ID.

### Step 7: Create tech activities
For each non-duplicate activity, call aws_sentral_mcp__create_tech_activity. Create in batches of 3-5 at a time.

Parameters:
- subject: meeting title
- description: 2-3 sentence summary of the engagement
- activityDate: YYYY-MM-DD
- parentRecord: opportunity ID or account ID
- saActivity: from mapping table (NOT always "Other Architectural Guidance")
- status: "Completed"
- isVirtual: true/false based on meeting location
- timeSpentHours: from actual calendar duration
- services: inferred AWS services (if any)
- domains: inferred technical domains (if any)
- industries: from account industry mapping

On UNABLE_TO_LOCK_ROW: retry up to 3 times with a brief pause. After 3 failures, log as failed and continue.

Track: created activity IDs, failed activities, skipped duplicates.

Write a progress checkpoint after each batch: account name + activities created so far. If context is exhausted mid-run, a re-run can skip completed accounts by checking the checkpoint.

### Step 8: Build Excel with run_python
Use run_python with xlsxwriter to create the spreadsheet.
Write DIRECTLY to {{EXPORT_PATH}}/tech_activities_YYYY_MM.xlsx.

Include these sheets:
- "All Activities": #, Date, Subject, Account, Opportunity, SA Activity, Services, Domains, Virtual, Hours, Task ID, AWSentral URL
- "Summary": Account, Activities count, Hours total, Services used
- "Data Gaps": Accounts with zero activities, opportunities with no engagement, unmapped meetings
- "Skipped Meetings": Meeting title, Date, Account, Reason skipped (recurring/internal/duplicate/etc.)
- "Failed Activities": Meeting title, Date, Account, Error message

AWSentral URL format: https://aws-crm.lightning.force.com/lightning/r/Task/{taskId}/view

### Step 9: Notify
Call update_feed with importance="important".
Include: count of activities created, duplicates skipped, failures, total hours, accounts covered, Excel file location, and any data gaps/questions.
```

---

## Setup Steps (Quick Reference)

1. **Gather your info**: SFDC User ID, account list with IDs, industries, export folder path
2. **Customize the prompt**: Replace all `{{...}}` placeholders (see [Placeholders to fill in](#placeholders-to-fill-in) table)
3. **Customize the mapping tables** (optional): The SA Activity and Service & Domain tables are already embedded in the prompt. Add keywords specific to your territory if needed.
4. **Create the agent** in Amazon Quick:
   - ID: `monthly-tech-activity-logger`
   - Schedule: `cron_like`, time `09:00`, days `[mon]`
   - Model: `thinking`
   - Tool policy: see [Tool Policy](#tool-policy) section
   - Paste your customized prompt
5. **Add the condition**: Create trigger `last-monday-check` with the Python code above
6. **Test the condition**: Verify it returns `False` on non-last-Mondays and a dict on the last Monday
7. **Test run**: Trigger the agent manually and review results
8. **Enable**: Turn the agent on once satisfied

---

## Customization Options

| What | How |
|------|-----|
| **Change run day** | Modify the trigger code to check for a different weekday or week-of-month |
| **Add more accounts** | Add entries to the "Key Accounts" section of the prompt AND the Account Industry Mapping |
| **Change export format** | Modify Step 8 in the prompt (e.g., CSV instead of Excel) |
| **Change export location** | Update `{{EXPORT_PATH}}` and the `file_write` path pattern in the tool policy |
| **Add Slack scanning** | Add a step between 3 and 4: search Slack channels for engagement context to enrich meeting classification. Requires `slack_mcp` in tool policy. |
| **Remove Slack entirely** | Remove `{ "group": "slack_mcp", "effect": "allow" }` from the tool policy |
| **Skip Excel export** | Remove Step 8 and the `file_write`/`run_python` tool policy entries |
| **Run weekly instead** | Remove the condition gate entirely; change schedule to desired frequency |
| **Add more industries** | Update the Account Industry Mapping section with per-account overrides |
| **Add more SA activity mappings** | Extend the SA Activity Mapping table with new keyword → enum pairs |
| **Add more service mappings** | Extend the Service & Domain Inference table for services common in your territory |

---

## Kiro Integration (Optional)

If you use [Kiro IDE](https://kiro.dev) alongside Amazon Quick, the agent can drop a handoff file for Kiro's downstream opportunity team membership check. This verifies you're on the opportunity team for every opp where you logged activities.

### To enable Kiro integration:

1. **Create the handoff directory**:
   - macOS/Linux: `mkdir -p ~/quick-kiro-handoff/`
   - Windows: `mkdir %USERPROFILE%\quick-kiro-handoff`
2. **Keep the handoff path** in the `file_write` tool policy pattern (it's already included above)
3. **Add Step 9b** to the agent prompt (insert between the current Step 8 and Step 9):

```
### Step 9b: Drop Kiro handoff file (optional — only if using Kiro)
Write a handoff file for Kiro's downstream team membership check:
~/quick-kiro-handoff/YYYY-MM-DD_quick_tech-activities-logged.md

Format:
# Tech Activities Logged — [Month] [Year]
Date: YYYY-MM-DD
Period: [first_of_month] to [last_of_month]

## Summary
- Activities created: X
- Duplicates skipped: Y
- Failed: Z
- Accounts covered: [list]
- Excel export: {{EXPORT_PATH}}/tech_activities_YYYY_MM.xlsx

## Opportunity IDs with Activities
- [opp_id_1] ([opp_name] — [account])
- [opp_id_2] ([opp_name] — [account])
...

## Action for Kiro
Run the opportunity team membership check for the opportunities listed above.
User SFDC ID: {{YOUR_SFDC_USER_ID}}
```

4. **Configure Kiro** to watch `~/quick-kiro-handoff/` for new files (see Kiro's `quick-collaboration.md` steering power)

### If you don't use Kiro:
- Remove `quick-kiro-handoff.*\\.md` from the `file_write` path pattern in the tool policy
- Skip Step 9b entirely

---

## Troubleshooting

| Issue | Fix |
|-------|-----|
| Agent runs but creates 0 activities | Check the agent session log — likely no calendar matches. Broaden account search terms or add email domain searches. Also check if all activities were flagged as duplicates. |
| `UNABLE_TO_LOCK_ROW` errors | SFDC row lock contention. The prompt retries up to 3 times per activity. If persistent, reduce batch size to 1-2. Check the "Failed Activities" sheet in the Excel export. |
| Context exhaustion (partial results) | Use `model: thinking` for larger context window. Reduce number of accounts per batch. The agent writes progress checkpoints — re-run will skip completed accounts. |
| Excel not created but activities were | The activities are in SFDC. Re-trigger the agent manually or run just Step 8 independently. Check the feed notification for details. |
| Agent never fires | Verify the condition trigger returns a dict on the correct day. Test with `test_trigger`. Check that the schedule is set to Monday. |
| Agent fires on wrong month | Check if Quick was offline on the last Monday. The agent uses target_month from the condition gate to scan the correct period regardless of when it actually runs. |
| Duplicate activities created | The deduplication step (Step 6) should prevent this. If duplicates appear, check that `search_tasks` is scoped correctly per opportunity/account. |
| Missing services/domains on activities | The inference is best-effort from meeting titles. For meetings with generic titles, services won't be set. This is expected — manual enrichment can be done in AWSentral UI. |
| Zero opportunities returned in Step 2 | Expected for new hires or empty territories. The agent will use Account IDs directly as parentRecord. Verify your account list is correct. |

---

## Architecture Notes

```
┌──────────────────────────────────────────────────────────────────────┐
│  Amazon Quick Scheduler                                              │
│  ┌───────────┐    ┌──────────────┐    ┌────────────────────────────┐ │
│  │ cron_like │───▶│ last-monday  │───▶│  Agent (LLM)               │ │
│  │ Mon 09:00 │    │ check.py     │    │  1. Determine date range   │ │
│  └───────────┘    │ gate=True?   │    │  2. Get opportunities      │ │
│                   └──────────────┘    │  3. Search calendar (batch) │ │
│                                       │  4. Filter meetings         │ │
│                                       │  5. Classify activities     │ │
│                                       │  6. Deduplicate             │ │
│                                       │  7. Create in AWSentral     │ │
│                                       │  8. Export Excel             │ │
│                                       │  9. Notify                  │ │
│                                       └─────────┬──────────────────┘ │
└─────────────────────────────────────────────────┼────────────────────┘
                                                  │
              ┌───────────────┬───────────────────┼───────────────────┐
              │               │                   │                   │
              ▼               ▼                   ▼                   ▼
     ┌────────────────┐ ┌──────────────┐ ┌───────────────┐ ┌─────────────────┐
     │ Outlook Calendar│ │ AWSentral    │ │ Desktop .xlsx │ │ Kiro Handoff    │
     │ (read meetings) │ │ (read+write) │ │ (export)      │ │ (optional)      │
     └────────────────┘ └──────────────┘ └───────────────┘ └─────────────────┘
```

---

## FAQ

**Q: What roles does this work for?**
A: Any SA, CSM, TAM, or other customer-facing role that logs tech activities in AWSentral/SFDC.

**Q: How many accounts can I include?**
A: There's no hard limit, but more accounts = longer runtime. Start with your top 5-10 and expand from there. The `thinking` model has a large context window.

**Q: Will this overwrite existing activities?**
A: No. Step 6 deduplicates against existing activities. If a matching activity already exists, it's skipped.

**Q: Can I run this mid-month?**
A: Yes — trigger it manually (the condition gate only applies to automated runs). It will scan the current month up to today.

**Q: What if I cover accounts across multiple industries?**
A: Set the industry per account in the Account Industry Mapping table. The prompt uses the correct industry for each activity.

**Q: Do I need Kiro for this to work?**
A: No. Kiro integration is entirely optional. Without it, the agent creates activities and exports the Excel — that's the core value.

**Q: Do I need Slack connected?**
A: No. Slack is optional. It helps the agent infer richer context (e.g., which AWS services were discussed), but the core flow only needs Outlook + AWSentral.

---

*Reusable agent blueprint for Amazon Quick Desktop. Contributions welcome — extend the mapping tables for your territory and share back.*